package com.example.demo.utils.json;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.example.demo.utils.date.DateUtils;
import com.example.demo.utils.reflection.ReflectionUtils;
import com.example.demo.utils.common.StringUtils;
import com.example.demo.utils.bean.BeanUtils;
import org.apache.commons.collections.MapUtils;
import org.apache.commons.lang3.ArrayUtils;

import java.util.*;

/**
 * JSON数据解析工具类
 */
public class JSONUtils {

	/**
	 * 根据Key值取得jasonObject的值
	 *
	 * @param jsonObject 传入的要取值的JasonObject对象
	 * @param key        key值，String型
	 * @return 根据Key值取得的jasonObject值
	 */
	public static String getString(JSONObject jsonObject, String key) {
		return getString(jsonObject, key, null);
	}

	/**
	 * String转换为JSONObject对象
	 *
	 * @param strObject 传入的JSON字符串
	 * @return JSON对象
	 */
	public static JSONObject fromObject(String strObject) {
		if (StringUtils.isEmpty(strObject)) {
			return null;
		} else {
			return JSONObject.parseObject(strObject);
		}
	}

	public static Object fromObject(Map<String, String> obj) {
		if (MapUtils.isEmpty(obj)) {
			return null;
		} else {
			return JSONObject.toJSON(obj);
		}
	}

	public static JSONObject fromObject(Object object) {
		if (object == null) {
			return null;
		} else {
			return (JSONObject) JSONObject.toJSON(object);
		}
	}

	/**
	 * 根据Key值取得jasonObject的值
	 *
	 * @param jsonObject 传入的要取值的JasonObject对象
	 * @param key        key值，String型
	 * @return 根据Key值取得的jasonObject值
	 */
	public static String getString(JSONObject jsonObject, String key, String defaultValue) {
		if (jsonObject == null) {
			return null;
		}
		if (!jsonObject.containsKey(key)) {
			return defaultValue;
		}

		return jsonObject.getString(key);
	}

	/**
	 * 判断jasonObject对象是否包含传入的key值，如果包含则返回该jasonObject对象的值，否则返回""
	 *
	 * @param jsonObject 要判断的jasonObject对象，JSONObject类型
	 * @param key        传入的Key值，String类型
	 * @return jasonObject对象包含传入的Key值，则返回该jasonObject对象的值，否则返回""
	 */
	public static String getEmptyString(JSONObject jsonObject, String key) {
		if (jsonObject == null) {
			return StringUtils.EMPTY;
		}
		if (!jsonObject.containsKey(key)) {
			return StringUtils.EMPTY;
		}
		Object value = jsonObject.get(key);
		if (value == null) {
			return StringUtils.EMPTY;
		}
		return jsonObject.getString(key);
	}

	/**
	 * 取得jasonObject对象中的整数值
	 *
	 * @param jsonObject 要取值的jasonObject对象
	 * @param key        key值，String型
	 * @return 如果jasonObject包含某个key值，则返回int型值，否则返回null
	 */
	public static Object getObject(JSONObject jsonObject, String key) {
		if (jsonObject == null) {
			return null;
		}

		if (jsonObject.containsKey(key)) {
			return jsonObject.get(key);
		}
		return null;
	}

	public static Double getDouble(JSONObject jsonObject, String key) {
		if (jsonObject == null) {
			return null;
		}

		if (jsonObject.containsKey(key)) {
			return jsonObject.getDoubleValue(key);
		}
		return null;
	}

	public static Double getDouble(JSONObject jsonObject, String key, double defaultValue) {
		if (jsonObject == null) {
			return null;
		}

		if (jsonObject.containsKey(key)) {
			String value = jsonObject.getString(key);
			if (StringUtils.isNotEmpty(value)) {
				return jsonObject.getDoubleValue(key);
			}
		}
		return defaultValue;
	}

	public static Long getLong(JSONObject jsonObject, String key) {
		if (jsonObject == null) {
			return null;
		}

		if (jsonObject.containsKey(key)) {
			return jsonObject.getLongValue(key);
		}
		return null;
	}

	public static Long getLong(JSONObject jsonObject, String key, Long defaultValue) {
		if (jsonObject == null) {
			return null;
		}

		if (jsonObject.containsKey(key)) {
			return jsonObject.getLongValue(key);
		}
		return defaultValue;
	}


	/**
	 * 取得jasonObject对象中的整数值
	 *
	 * @param jsonObject 要取值的jasonObject对象
	 * @param key        key值，String型
	 * @return 如果jasonObject包含某个key值，则返回int型值，否则返回null
	 */
	public static Byte getByte(JSONObject jsonObject, String key) {
		if (jsonObject == null) {
			return null;
		}

		if (jsonObject.containsKey(key)) {
			return jsonObject.getByte(key);
		}
		return null;
	}

	/**
	 * 取得jasonObject对象中的整数值
	 *
	 * @param jsonObject 要取值的jasonObject对象
	 * @param key        key值，String型
	 * @return 如果jasonObject包含某个key值，则返回int型值，否则返回null
	 */
	public static Byte getByte(JSONObject jsonObject, String key, byte defaultValue) {
		if (jsonObject == null) {
			return null;
		}
		if (jsonObject.containsKey(key)) {
			return jsonObject.getByte(key);
		}
		return defaultValue;
	}

	/**
	 * 取得jasonObject对象中的整数值
	 *
	 * @param jsonObject 要取值的jasonObject对象
	 * @param key        key值，String型
	 * @return 如果jasonObject包含某个key值，则返回int型值，否则返回null
	 */
	public static Integer getInteger(JSONObject jsonObject, String key) {
		if (jsonObject == null) {
			return null;
		}

		if (jsonObject.containsKey(key)) {
			return jsonObject.getInteger(key);
		}
		return null;
	}

	/**
	 * 取得jasonObject对象中的整数值
	 *
	 * @param jsonObject 要取值的jasonObject对象
	 * @param key        key值，String型
	 * @return 如果jasonObject包含某个key值，则返回int型值，否则返回null
	 */
	public static Integer getInteger(JSONObject jsonObject, String key, int defaultValue) {
		if (jsonObject == null) {
			return null;
		}
		if (jsonObject.containsKey(key)) {
			Integer value = jsonObject.getInteger(key);
			if (value == null) {
				return defaultValue;
			} else {
				return value;
			}
		}
		return defaultValue;
	}

	/**
	 * 取得jasonObject对象中的整数值
	 *
	 * @param jsonObject 要取值的jasonObject对象
	 * @param key        key值，String型
	 * @return 如果jasonObject包含某个key值，则返回int型值，否则返回null
	 */
	public static Boolean getBoolean(JSONObject jsonObject, String key) {
		if (jsonObject == null) {
			return null;
		}
		if (jsonObject.containsKey(key)) {
			return jsonObject.getBoolean(key);
		}
		return null;
	}

	/**
	 * 取得jasonObject对象中的整数值
	 *
	 * @param jsonObject 要取值的jasonObject对象
	 * @param key        key值，String型
	 * @return 如果jasonObject包含某个key值，则返回int型值，否则返回null
	 */
	public static Boolean getBoolean(JSONObject jsonObject, String key, boolean defaultValue) {
		if (jsonObject == null) {
			return null;
		}
		if (jsonObject.containsKey(key)) {
			return jsonObject.getBoolean(key);
		}
		return defaultValue;
	}

	/**
	 * 给jasonObject对象中赋值
	 *
	 * @param jsonObject 要赋值的jasonObject对象
	 * @param name       key值， String型
	 * @param value      value值 ，String型
	 */
	public static void setString(JSONObject jsonObject, String name, String value) {
		jsonObject.put(name, value);
	}

	/**
	 * 给jasonObject对象中赋值
	 *
	 * @param jsonObject 要赋值的jasonObject对象
	 * @param name       key值， String型
	 */
	public static JSONObject getJSONObject(JSONObject jsonObject, String name) {
		return getJSONObject(jsonObject, name, null);
	}

	/**
	 * 给jasonObject对象中赋值
	 *
	 * @param jsonObject 要赋值的jasonObject对象
	 * @param name       key值， String型
	 * @param value      value值 ，String型
	 */
	public static JSONObject getJSONObject(JSONObject jsonObject, String name, JSONObject value) {
		if (jsonObject == null) {
			return null;
		}
		if (jsonObject.containsKey(name)) {
			return jsonObject.getJSONObject(name);
		}
		return value;
	}

	/**
	 * 给jasonObject对象中赋值
	 *
	 * @param jsonObject 要赋值的jasonObject对象
	 * @param name       key值， String型
	 */
	public static JSONArray getJSONArray(JSONObject jsonObject, String name) {
		if (jsonObject == null) {
			return null;
		}
		return getJSONArray(jsonObject, name, null);
	}

	/**
	 * 给jasonObject对象中赋值
	 *
	 * @param jsonObject 要赋值的jasonObject对象
	 * @param name       key值， String型
	 * @param value      value值 ，String型
	 */
	public static JSONArray getJSONArray(JSONObject jsonObject, String name, JSONArray value) {
		if (jsonObject.containsKey(name)) {
			return jsonObject.getJSONArray(name);
		}
		return value;
	}

	/**
	 * 给jasonObject对象中赋值
	 *
	 * @param jsonObject 要赋值的jasonObject对象
	 * @param name       key值， String型
	 */
	public static String[] getStringArray(JSONObject jsonObject, String name) {
		if (jsonObject == null) {
			return null;
		}
		return getStringArray(jsonObject, name, null);
	}

	/**
	 * 给jasonObject对象中赋值
	 *
	 * @param jsonObject 要赋值的jasonObject对象
	 * @param name       key值， String型
	 */
	public static String[] getStringArray(JSONObject jsonObject, String name, String[] defaultValue) {
		if (jsonObject == null) {
			return null;
		}
		if (jsonObject.containsKey(name)) {
			JSONArray jsonArray = getJSONArray(jsonObject, name);
			return toStringArray(jsonArray);
		}

		return defaultValue;
	}

	public static String[] toStringArray(JSONArray jsonArray) {
		if (jsonArray == null) {
			return null;
		}
		int size = jsonArray.size();
		String[] strs = new String[size];
		for (int i = 0; i < size; i++) {
			strs[i] = jsonArray.getString(i);
		}
		return strs;
	}

	public static int[] getIntegerArray(JSONObject jsonObject, String name) {
		return getIntegerArray(jsonObject, name, null);
	}

	public static int[] getIntegerArray(JSONObject jsonObject, String name, int[] defaultValue) {
		if (jsonObject.containsKey(name)) {
			JSONArray jsonArray = getJSONArray(jsonObject, name);
			return toIntegerArray(jsonArray);
		}

		return defaultValue;
	}

	public static int[] toIntegerArray(JSONArray jsonArray) {
		int size = jsonArray.size();
		int[] nums = new int[size];
		for (int i = 0; i < size; i++) {
			nums[i] = jsonArray.getInteger(i);
		}
		return nums;
	}

//	public static Integer[] getIntegerArray(JSONObject jsonObject, String name) {
//		return getIntegerArray(jsonObject, name, null);
//	}
//
//	public static Integer[] getIntegerArray(JSONObject jsonObject, String name, Integer[] defaultValue) {
//		if (jsonObject.containsKey(name)) {
//			JSONArray jsonArray = getJSONArray(jsonObject, name);
//			return toIntegerArray(jsonArray);
//		}
//
//		return defaultValue;
//	}
//
//	public static Integer[] toIntegerArray(JSONArray jsonArray) {
//		int size = jsonArray.size();
//		Integer[] nums = new Integer[size];
//		for (int i = 0; i < size; i++) {
//			nums[i] = jsonArray.getInteger(i);
//		}
//		return nums;
//	}

	public static long[] getLongArray(JSONObject jsonObject, String name) {
		return getLongArray(jsonObject, name, null);
	}

	public static long[] getLongArray(JSONObject jsonObject, String name, long[] defaultValue) {
		if (jsonObject.containsKey(name)) {
			JSONArray jsonArray = getJSONArray(jsonObject, name);
			return toLongArray(jsonArray);
		}

		return defaultValue;
	}

	public static long[] toLongArray(JSONArray jsonArray) {
		int size = jsonArray.size();
		long[] nums = new long[size];
		for (int i = 0; i < size; i++) {
			nums[i] = jsonArray.getLong(i);
		}
		return nums;
	}

	public static double[] getDoubleArray(JSONObject jsonObject, String name) {
		return getDoubleArray(jsonObject, name, null);
	}

	public static double[] getDoubleArray(JSONObject jsonObject, String name, double[] defaultValue) {
		if (jsonObject.containsKey(name)) {
			JSONArray jsonArray = getJSONArray(jsonObject, name);
			return toDoubleArray(jsonArray);
		}

		return defaultValue;
	}

	public static double[] toDoubleArray(JSONArray jsonArray) {
		int size = jsonArray.size();
		double[] nums = new double[size];
		for (int i = 0; i < size; i++) {
			nums[i] = jsonArray.getDouble(i);
		}
		return nums;
	}

	public static boolean[] getBooleanArray(JSONObject jsonObject, String name) {
		return getBooleanArray(jsonObject, name, null);
	}

	public static boolean[] getBooleanArray(JSONObject jsonObject, String name, boolean[] defaultValue) {
		if (jsonObject.containsKey(name)) {
			JSONArray jsonArray = getJSONArray(jsonObject, name);
			return toBooleanArray(jsonArray);
		}

		return defaultValue;
	}

	public static boolean[] toBooleanArray(JSONArray jsonArray) {
		int size = jsonArray.size();
		boolean[] nums = new boolean[size];
		for (int i = 0; i < size; i++) {
			nums[i] = jsonArray.getBoolean(i);
		}
		return nums;
	}

	/**
	 * 格式化输出jasonObject中的日期值
	 *
	 * @param jsonObject 要取值的jasonObject对象
	 * @param key        key值
	 * @param dateFromat 指定日期输出的格式
	 * @return 如果jasonObject对象中包含某个key值，则返回按照dataFormat指定的格式输出，否则返回null
	 */
	public static Date getDate(JSONObject jsonObject, String key, String dateFromat) {
		String value = getString(jsonObject, key);
		if (StringUtils.isNotEmpty(value)) {
			return DateUtils.parse(value, dateFromat);
		}
		return null;
	}

	public static Date[] getDateArray(JSONObject jsonObject, String name, String dateFromat) {
		return getDateArray(jsonObject, name, dateFromat, null);
	}

	public static Date[] getDateArray(JSONObject jsonObject, String name, String dateFromat, Date[] defaultValue) {
		if (jsonObject.containsKey(name)) {
			JSONArray jsonArray = getJSONArray(jsonObject, name);
			return toDateArray(jsonArray, dateFromat);
		}

		return defaultValue;
	}

	public static Date[] toDateArray(JSONArray jsonArray, String dateFromat) {
		int size = jsonArray.size();
		Date[] dates = new Date[size];
		for (int i = 0; i < size; i++) {
			String dateString = jsonArray.getString(i);
			;
			dates[i] = DateUtils.parse(dateString, dateFromat);
		}
		return dates;
	}

	public static void element(JSONObject jsonObject, String name, Object valueObject) {
		jsonObject.put(name, valueObject);
	}

	public static void element(JSONObject jsonObject, String name, double valueObject) {
		jsonObject.put(name, valueObject);
	}

	public static void element(JSONObject jsonObject, String name, int valueObject) {
		jsonObject.put(name, valueObject);
	}

	public static void element(JSONObject jsonObject, String name, long valueObject) {
		jsonObject.put(name, valueObject);
	}

	public static void element(JSONObject jsonObject, String name, Date valueObject, String dateFromat) {
		jsonObject.put(name, DateUtils.format(valueObject, dateFromat));
	}

	public static JSONArray fromArray(String str) {
		return JSONArray.parseArray(str);
	}

	public static Object fromArray(List<?> list) {
		return JSONArray.toJSON(list);
	}

	public static JSONArray fromArray(Object object) {
		JSONArray jSONArray = new JSONArray();
		if (object == null) {
			return jSONArray;
		}
		if (object instanceof String) {
			jSONArray = fromArray(object.toString());
		} else {
			jSONArray = (JSONArray) JSONArray.toJSON(object);
		}

		return jSONArray;
	}

	/**
	 * 取得json数组
	 *
	 * @param os list
	 * @return json数组
	 */
	public static JSONArray toJSONArray(Object[] os) {
		JSONArray array = null;

		if (os != null) {
			array = new JSONArray();
			for (int i = 0; i < os.length; i++) {
				array.add(JSONUtils.toJSONObject(os[i]));
			}
		}

		return array;
	}

	public static JSONArray toJSONArray(String[] values) {
		if (ArrayUtils.isEmpty(values)) {
			return null;
		}

		JSONArray valueObjects = new JSONArray();
		for (String value : values) {
			valueObjects.add(value);
		}

		return valueObjects;
	}

	public static JSONArray toJSONArray(Date[] values, String pattern) {
		if (ArrayUtils.isEmpty(values)) {
			return null;
		}

		JSONArray valueObjects = new JSONArray();
		for (Date value : values) {
			valueObjects.add(DateUtils.format(value, pattern));
		}

		return valueObjects;
	}

	public static JSONArray toJSONArray(Integer[] values) {
		if (ArrayUtils.isEmpty(values)) {
			return null;
		}

		JSONArray valueObjects = new JSONArray();
		for (int value : values) {
			valueObjects.add(value);
		}

		return valueObjects;
	}

	public static JSONArray toJSONArray(Long[] values) {
		if (ArrayUtils.isEmpty(values)) {
			return null;
		}

		JSONArray valueObjects = new JSONArray();
		for (long value : values) {
			valueObjects.add(value);
		}

		return valueObjects;
	}

	public static JSONArray toJSONArray(Double[] values) {
		if (ArrayUtils.isEmpty(values)) {
			return null;
		}

		JSONArray valueObjects = new JSONArray();
		for (double value : values) {
			valueObjects.add(value);
		}

		return valueObjects;
	}

	/**
	 * 取得json数组
	 *
	 * @param os list
	 * @return json数组
	 */
	public static JSONArray toJSONArray(List<?> os, Class<?> clazz) {
		return JSONUtils.toJSONArray(os, new BeanTransformer(clazz));
	}

	/**
	 * 取得json数组
	 *
	 * @param os     list
	 * @param fields key数组
	 * @return json数组
	 */
	public static JSONArray toJSONArray(List<?> os, String[] fields) {
		JSONArray gridData = new JSONArray();
		if (os != null) {
			return toJSONArray(os, new BeanTransformer(fields));
		}

		return gridData;
	}

	/**
	 * 取得json数组
	 *
	 * @param os     list
	 * @return json数组
	 */
	public static JSONArray toJSONArray(List<?> os, JSONObjectTransformer transformer) {
		JSONArray gridData = new JSONArray();
		if (os != null) {
			// 遍历os，生成json对象，并保存在json数组中
			for (Object o : os) {
				JSONObject oObject = transformer.to(o);
				gridData.add(oObject);
			}
		}

		return gridData;
	}

	/**
	 * 取得json数组
	 *
	 * @param os     list
	 * @param fields key数组
	 * @return json数组
	 */
	public static JSONArray toJSONArray(Object[] os, String[] fields) {
		JSONArray gridData = new JSONArray();
		if (os != null) {
			// 遍历os，生成json对象，并保存在json数组中
			for (Object o : os) {
				JSONObject rowData = JSONUtils.toJSONObject(o, fields);
				gridData.add(rowData);
			}
		}

		return gridData;
	}

	/**
	 * 取得json数组
	 *
	 * @param os         list
	 * @param objFields  value数组
	 * @param jsonFields key数组
	 * @return json数组
	 */
	public static JSONArray toJSONArray(List<?> os, String[] objFields, String[] jsonFields) {
		JSONArray gridData = new JSONArray();
		if (os != null) {
			// 遍历os，生成json对象，并保存在json数组中
			for (Object o : os) {
				JSONObject rowData = JSONUtils.toJSONObject(o, objFields, jsonFields);
				gridData.add(rowData);
			}
		}

		return gridData;
	}

	public static JSONObject toJSONObject(Map<Byte, Integer> map) {
		JSONObject jsonObject = new JSONObject();

		Set<Byte> keySet = map.keySet();
		if (keySet != null) {
			for (Byte key : keySet) {
				int value = map.get(key);
				JSONUtils.element(jsonObject, StringUtils.toHexString(key), value);
			}
		}

		return jsonObject;
	}

	/**
	 * 给指定对象的指定属性赋上指定属性(含get或is方法的属性)名作为值
	 *
	 * @param o 指定对象
	 * @return
	 */
	public static JSONObject toJSONObject(Object o) {
		Class<?> clazz = o.getClass();
		List<String> fields = ReflectionUtils.findBeanNames(clazz);
		return JSONUtils.toJSONObject(o, fields.toArray(new String[0]));
	}

	/**
	 * 给指定对象的指定属性(含get或is方法的属性)赋上指定属性名作为值
	 *
	 * @param o      指定对象
	 * @param fields 指定属性
	 * @return
	 */
	public static JSONObject toJSONObject(Object o, String[] fields) {
		return JSONUtils.toJSONObject(o, fields, fields);
	}

	/**
	 * 为指定对象内指定属性(含get或is方法的属性)赋指定值，返回一个属性与值对应的json对象
	 *
	 * @param o          指定对象
	 * @param objFields  指定属性
	 * @param jsonFields 指定值
	 * @return
	 */
	public static JSONObject toJSONObject(Object o, String[] objFields, String[] jsonFields) {
		if (null == o) {
			return null;
		}
		JSONObject jsonObject = new JSONObject();

		// 如果没有指定属性则获取制定对象内属性
		if (objFields == null) {
			List<String> fs = BeanUtils.getBeanFieldNames(o);
			objFields = fs.toArray(new String[0]);
		}

		// 如果没有指定值则指定值等于指定属性名称
		if (jsonFields == null) {
			jsonFields = objFields;
		}

		// 指定属性不为空则遍历指定属性并为其赋上对应的指定值并转换为json对象
		if (objFields != null) {
			for (int i = 0; i < objFields.length; i++) {
				String field = objFields[i];
				// 处理日期型的数据与json的转换
				if (field.indexOf("|") > 0) {
					String strValue = null;
					String[] fieldArray = StringUtils.split(field, "|");
					Object value = BeanUtils.getValue(o, fieldArray[0]);
					if (null != value) {
						if (value instanceof Date) {
							strValue = DateUtils.format((Date) value, fieldArray[1]);
						} else {
							strValue = String.valueOf(value);
						}
					}

					String[] jsonFieldArray = StringUtils.split(jsonFields[i], "|");
					element(jsonObject, jsonFieldArray[0], strValue);
				} else {
					Object value = BeanUtils.getValue(o, field);
					if (null != value) {
						if (value instanceof Date) {
							value = DateUtils.format((Date) value, DateUtils.yyyyMMddHHmmss);
						}
					}
					element(jsonObject, jsonFields[i], value);
				}
			}
		}

		return jsonObject;
	}

	/**
	 * 为指定对象的属性（包含set方法属性）赋值
	 *
	 * @param clazzPath  指定对象
	 * @param jsonString 赋值内容json串
	 * @return
	 */
	public static Object toJavaObject(String clazzPath, String jsonString) {
		Object object = ReflectionUtils.newInstance(clazzPath);
		JSONObject jsonObject = fromObject(jsonString);
		Set<?> keys = jsonObject.keySet();
		if (keys != null) {
			for (Object o : keys) {
				String name = (String) o;
				Object value = jsonObject.get(name);
				// 调用set方法为指定属性赋值
				ReflectionUtils.invokeSetMethod(object, name, value);
			}
		}

		return object;
	}

	public static <T> T toJavaObject(JSON json, Class<T> clazz) {
		return JSONObject.toJavaObject(json, clazz);
	}

	public static String format(JSONObject jsonObject) {
		return format(jsonObject.toString());
	}

	public static String format(JSONArray jsonArray) {
		return format(jsonArray.toString());
	}

	/**
	 * 得到格式化json数据 退格用\t 换行用\r
	 */
	public static String format(String jsonStr) {
		int level = 0;
		StringBuffer jsonForMatStr = new StringBuffer();
		for (int i = 0; i < jsonStr.length(); i++) {
			char c = jsonStr.charAt(i);
			if (level > 0 && '\n' == jsonForMatStr.charAt(jsonForMatStr.length() - 1)) {
				jsonForMatStr.append(getLevelStr(level));
			}
			switch (c) {
				case '{':
				case '[':
					jsonForMatStr.append(c + "\n");
					level++;
					break;
				case ',':
					jsonForMatStr.append(c + "\n");
					break;
				case '}':
				case ']':
					jsonForMatStr.append("\n");
					level--;
					jsonForMatStr.append(getLevelStr(level));
					jsonForMatStr.append(c);
					break;
				default:
					jsonForMatStr.append(c);
					break;
			}
		}

		return jsonForMatStr.toString();

	}

	private static String getLevelStr(int level) {
		StringBuffer levelStr = new StringBuffer();
		for (int levelI = 0; levelI < level; levelI++) {
			levelStr.append("  ");
		}
		return levelStr.toString();
	}

	public static <T> List<T> toJavaObjects(JSONArray jsonObjects, Class<T> clazz) {
		return toJavaObjects(jsonObjects, clazz, new BeanTransformer(clazz));
	}

	public static <T> List<T> toJavaObjects(JSONArray jsonObjects, Class<T> clazz, JSONObjectTransformer transformer) {
		List<T> javaObjects = new ArrayList<>();
		int count = jsonObjects.size();
		for (int i = 0; i < count; i++) {
			JSONObject rowObject = jsonObjects.getJSONObject(i);
			T row = transformer.from(clazz, rowObject);
			javaObjects.add(row);
		}

		return javaObjects;
	}

}
